// HTTP请求工具类（使用uni.request替代axios）

// 检查是否在小程序环境中
const isMP = typeof uni !== 'undefined'

// 基础配置
const config = {
  // 不管环境都使用固定地址
    baseURL: 'http://127.0.0.1:8800',
  //  baseURL: 'http://192.168.0.93:8800',
  timeout: 5000, // 增加超时时间
  header: {
    'Content-Type': 'application/json'
  }
}
// 请求方法
const http = {
  request(options) {
    // 打印调试信息
    console.log('发起请求:', options)
    
    // 处理URL
    let url = ''
    if (options.url.startsWith('http')) {
      url = options.url
    } else {
      // 确保URL格式正确
      url = config.baseURL + (options.url.startsWith('/') ? options.url : `/${options.url}`)
    }
    
    console.log('请求完整URL:', url)
    
    // 合并请求头
    const token = isMP ? uni.getStorageSync('token') : ''
    const header = {
      ...config.header,
      ...(options.header || {})
    }
    
    // 如果有token则携带
    if (token) {
      header['Authorization'] = `${token}`
    }
    
    // 添加小程序相关信息
    if (isMP) {
      try {
        const systemInfo = uni.getSystemInfoSync()
        header['X-Client-Type'] = 'miniprogram'
        header['X-Client-Version'] = systemInfo.appVersion || '1.0.0'
        header['X-Client-Platform'] = systemInfo.platform
      } catch (error) {
        console.error('获取系统信息失败:', error)
      }
    }
    
    // 添加时间戳防止GET请求缓存
    let data = options.data || {}
    if (options.method === 'GET' || options.method === 'get') {
      data = {
        ...data,
        _t: Date.now()
      }
    }
    
    // 打印请求信息
    console.log('请求方法:', options.method)
    console.log('请求头:', header)
    console.log('请求数据:', data)
    
    // 返回Promise对象
    return new Promise((resolve, reject) => {
      // 检查是否支持uni
      if (!isMP) {
        reject(new Error('当前环境不支持uni对象'))
        return
      }
      
      // 使用uniapp提供的请求方法
      uni.request({
        url,
        data,
        method: options.method,
        header,
        timeout: options.timeout || config.timeout,
        success: (response) => {
          console.log('请求成功, 响应数据:', response)
          
          // 返回原始响应用于调试
          if (!response.data) {
            resolve(response)
            return
          }
          
          const res = response.data
          
          // 状态码处理
          if (response.statusCode !== 200) {
            handleErrorResponse(response, reject)
            return
          }
          
          // 修改：增强检查业务状态码的逻辑
          if (typeof res === 'object' && res !== null) {
            // 检查返回对象中是否包含code属性（包括不同类型）
            if (res.code !== undefined) {
              // 如果code存在且不等于200，则认为是业务错误
              if (res.code !== 200 && res.code !== 201) {
                handleBusinessError(res, reject)
                return
              }
              
              // 返回数据，优先返回res.data，如果不存在则返回整个res
              resolve(res)
              return
            } 
            
            // 检查是否有其他可能的状态码字段
            if (res.statusCode !== undefined) {
              if (res.statusCode !== 200 && res.statusCode !== 201) {
                handleBusinessError({ code: res.statusCode, message: res.message || '请求失败' }, reject)
                return
              }
              
              resolve(res)
              return
            }
          }
          
          // 如果没有明确的状态码字段，直接返回响应数据
          resolve(res)
        },
        fail: (error) => {
          console.error('请求失败:', error)
          
          // 显示详细错误信息
          let errorMsg = '网络请求失败'
          if (error.errMsg) {
            errorMsg += `: ${error.errMsg}`
          }
          
          if (isMP) {
            uni.showToast({
              title: errorMsg,
              icon: 'none',
              duration: 2000
            })
          }
          reject(error)
        },
        complete: () => {
          console.log('请求完成')
        }
      })
    })
  },
  
  // GET请求
  get(url, data = {}) {
    // 处理URL参数
    if (url.includes('/${code}')) {
      url = url.replace('/${code}', `/${data.code}`)
      delete data.code
    }
    
    return this.request({
      url,
      method: 'GET',
      data
    })
  },
  
  // POST请求
  post(url, data = {}, config = {}) {
    return this.request({
      url,
      method: 'POST',
      data,
      timeout: config.timeout || config.timeout === 0 ? config.timeout : undefined
    })
  },
  
  // PUT请求
  put(url, data = {}) {
    return this.request({
      url,
      method: 'PUT',
      data
    })
  },
  
  // DELETE请求
  delete(url, data = {}) {
    return this.request({
      url,
      method: 'DELETE',
      data
    })
  }
}

// 处理HTTP状态码错误
function handleErrorResponse(response, reject) {
  console.error('HTTP状态码错误:', response.statusCode)
  
  if (!isMP) {
    reject(new Error(`HTTP错误: ${response.statusCode}`))
    return
  }
  
  switch (response.statusCode) {
    case 401:
      uni.showToast({
        title: '登录已过期，请重新登录',
        icon: 'none',
        duration: 2000
      })
      
      // 清除token
      uni.removeStorageSync('token')
      
      // 跳转到登录页
      setTimeout(() => {
        uni.reLaunch({
          url: '/pages/login/login'
        })
      }, 1500)
      break
      
    case 404:
      uni.showToast({
        title: '请求的资源不存在',
        icon: 'none',
        duration: 2000
      })
      break
      
    case 500:
      uni.showToast({
        title: '服务器内部错误',
        icon: 'none',
        duration: 2000
      })
      break
      
    default:
      uni.showToast({
        title: `请求错误(${response.statusCode})`,
        icon: 'none',
        duration: 2000
      })
  }
  
  reject(new Error(`HTTP错误: ${response.statusCode}`))
}

// 处理业务错误
function handleBusinessError(res, reject) {
  console.error('业务错误:', res.code, res.message)
  
  if (!isMP) {
    reject(new Error(res.message || '未知错误'))
    return
  }
  
  if (res.code === 401) {
    // token过期或未登录
    uni.showToast({
      title: '登录已过期，请重新登录',
      icon: 'none',
      duration: 2000
    })
    
    // 清除token
    uni.removeStorageSync('token')
    
    // 跳转到登录页
    setTimeout(() => {
      uni.reLaunch({
        url: '/pages/login/login'
      })
    }, 1500)
  } else if (res.code === 403) {
    // 权限不足
    uni.showToast({
      title: '权限不足',
      icon: 'none',
      duration: 2000
    })
  } else {
    // 其他错误
    uni.showToast({
      title: res.message || '服务器异常',
      icon: 'none',
      duration: 2000
    })
  }
  
  reject(new Error(res.message || '未知错误'))
}

export default http 